﻿#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

// word1 和 word2 中从 'a' 到 'z' 每一个字母出现频率之差都 不超过 3 ，
//那么我们称这两个字符串 word1 和 word2 几乎相等 。

//给你两个长度都为 n 的字符串 word1 和 word2 ，如果 word1 和 word2 几乎相等 ，
//请你返回 true ，否则返回 false 。


// 分别映射到两个数组中，分别进行判断个数是否相差3
class Solution {
public:
    bool checkAlmostEquivalent(string word1, string word2) {
        vector<int> table1(26, 0);
        vector<int> table2(26, 0);
        for (auto& ch : word1)
        {
            table1[ch - 'a']++;
        }
        for (auto& ch : word2)
        {
            table2[ch - 'a']++;
        }
        for (auto& ch : word1)
        {
            if (abs(table1[ch - 'a'] - table2[ch - 'a']) > 3)
                return false;
        }
        for (auto& ch : word2)
        {
            if (abs(table1[ch - 'a'] - table2[ch - 'a']) > 3)
                return false;
        }
        return true;
    }
};

class Solution {
public:
    bool checkAlmostEquivalent(string word1, string word2) {
        //用来记录字母出现次数
        vector<int> table(26, 0);
        for (size_t i = 0; i < word1.size(); ++i)
        {
            //word1出现的字母就加1
            table[word1[i] - 'a']++;
            //word2出现的字母就相应的减1
            table[word2[i] - 'a']--;
        }
        for (size_t i = 0; i < 26; ++i)
        {
            //判断绝对值数是否大于3
            if (abs(table[i]) > 3)
                return false;
        }

        return true;
    }
};

//给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

//注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size())
            return false;
        vector<int> table(26, 0);
        //对字母进行映射，然后判断在不在，不在返回false
        for (auto& ch : s)
        {
            table[ch - 'a']++;
        }
        for (auto& ch : t)
        {
            if (table[ch - 'a'] > 0)
                table[ch - 'a']--;
            else
                return false;
        }

        return true;
    }
};

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size())
            return false;
        sort(s.begin(), s.end());
        sort(t.begin(), t.end());
        return s == t;
    }
};

//给你一个偶数长度的字符串 s 。将其拆分成长度相同的两半，前一半为 a ，后一半为 b 。

//两个字符串 相似 的前提是它们都含有相同数目的元音（'a'，'e'，'i'，'o'，'u'，'A'，'E'，'I'，'O'，'U'）。
//注意，s 可能同时含有大写和小写字母。

//如果 a 和 b 相似，返回 true ；否则，返回 false

class Solution {
public:
    bool halvesAreAlike(string s) {
        string t;
        for (size_t i = 0; i < s.size() / 2; ++i)
        {
            t += s[i];
        }
        int count1 = 0;
        for (auto& ch : t)
        {
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
                ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U')
            {
                count1++;
            }
        }
        int count2 = 0;
        for (size_t i = s.size() / 2; i < s.size(); ++i)
        {
            if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u' ||
                s[i] == 'A' || s[i] == 'E' || s[i] == 'I' || s[i] == 'O' || s[i] == 'U')
            {
                count2++;
            }
        }

        return count1 == count2;
    }
};

//给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序
class Solution {
public:
    string reverseWords(string s) {
        int i = 0;
        while (i < s.size())
        {
            // 为空格直接跳过
            while (i < s.size() && s[i] == ' ')
            {
                ++i;
            }

            // 记录第一个不为空格的位置
            int start = i;
            while (i < s.size() && s[i] != ' ')
            {
                ++i;
            }
            // 反转第一个不为空格的位置到位空格的位置
            reverse(s.begin() + start, s.begin() + i);
        }

        return s;
    }
};

class Solution {
public:
    string reverseWords(string s) {
        string ret;
        string tmp;
        for (auto& ch : s)
        {
            if (ch != ' ')
            {
                tmp += ch;
            }
            else
            {
                reverse(tmp.begin(), tmp.end());
                ret += tmp;
                ret += ' ';
                tmp.clear();
            }
        }
        reverse(tmp.begin(), tmp.end());
        ret += tmp;
        return ret;
    }
};

class Solution {
public:
    string reverseWords(string s) {
        int start = 0;
        int pos = 0;
        while (start < s.size())
        {
            // 从start位置开始，从前往后找最近的一个空格
            pos = s.find(' ', start);
            // 如果pos是-1，说明[start, s.size())刚好是最后一个单词，调整下pos
            if (pos == -1)
            {
                pos = s.size();
            }
            // 逆置[start, pos)表示的单词
            reverse(s.begin() + start, s.begin() + pos);
            // 将start挪动到下一个单词的起始位置
            start = pos + 1;
        }

        return s;
    }
};

// 给你一个字符串 s ，字符串的「能量」定义为：只包含一种字符的最长非空子字符串的长度。
class Solution {
public:
    int maxPower(string s) {
        int ret = 0;
        int count = 1;
        for (size_t i = 0; i < s.size(); ++i)
        {
            // 如果两个字符相同，给该字符出现次数+1
            if (s[i] == s[i + 1])
            {
                count++;
            }
            else
            {
                // 如果两个字符不相等，说明s[i]是第一次出现，将才会Count设置为1
                // 并与最大的数进行比较
                if (count > ret)
                {
                    ret = count;
                }
                count = 1;
            }
        }

        return ret;
    }
};
int main()
{
    return 0;
}